package 蚂蚁课堂;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * SynchronousQueue：阻塞队列
 * 是一个内部只能包含一个元素的队列。插入元素到队列的线程被阻塞，直到另一个线程从队列中获取了队列中存储的元素。
 * 同样，如果线程尝试获取元素并且当前不存在任何元素，则该线程将被阻塞，直到线程将元素插入队列。
 * 对于每一个take的线程会阻塞直到有一个put的线程放入元素为止，反之亦然。在SynchronousQueue内部没有任何存放元素的能力
 * 所以SynchronousQueue队列不适用在高并发情况下
 */
public class SynchronousQueueDemo {

    static  SynchronousQueue<Integer> synchronousQueue=new SynchronousQueue();

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                publis();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                cuntomer();
            }
        }).start();
    }

    /**
     * 队列生产者
     */
    public static void publis(){
        IntStream.range(1,20).forEach(x->{
            try {
                System.out.println("生产者执行....."+x);
                synchronousQueue.put(x);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 队列消费者
     */
    public static void cuntomer() {

        while (true){
            Integer take = null;
            try {
                TimeUnit.SECONDS.sleep(1);
                take = synchronousQueue.take();
                System.out.println("消费者执行......"+take);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
